/*#include "bonus.h"*/
#include "jeu.h"
#include "fruit.h"
#include "menu.h"

#include <time.h>
#include <SDL/SDL_ttf.h>


    /*-----------------------------------------------*/
    /*                                               */
    /*                     JEU.C                     */
    /*                                               */
    /*-----------------------------------------------*/



int score(int compteurFruit, int compteurBonus, int difficulte)
{
		return (((compteurFruit-1)*10)+(compteurBonus*50)) / difficulte;
}

void definitionMur(int * tab, int M)
{
    /*DECLARATION DES VARIABLES*/
    int i, j;

    /*DEBUT DE LA BOUCLE POUR PARCOURIR TOUT LE TERRAIN*/
    for (i=0; i<DIMX; i++ )
    {
        for (j=0 ; j<DIMY; j++)
        {
            tab[M * 0 + i ] = 5;        /* MET TOUTES LES VALEURS DE LA PREMIERE COLONNE A 5*/
            tab[M * (DIMY-1) + i] = 5;  /* MET TOUTES LES VALEURS DE LA DERNIERE COLONNE A 5*/
            tab[M * j + 0] = 5;         /* MET TOUTES LES VALEURS DE LA PREMIERE LIGNE A 5*/
            tab[M * j + (DIMX-1)] = 5;  /* MET TOUTES LES VALEURS DE LA DERNIERE LIGNE A 5*/
        }
    }
}

int testFinJeu(serpent s,int * tab, int M, SDL_Surface *ecran, int score)
{
    /*DECLARATION DES VARIABLES*/
        /*VARIABLES PERMETTANT DE RECUPERER LA POSITION DE LA TETE DU SERPENT*/
    int posx;
    int posy;
        /*VARIABLES PERMETTANT DE RECUPERER LA VALEUR DE LA POSITION DES MURS*/
    int posxFin;
    int posyFin;

    /*CREATION D'UNE CELLULE PERMETTANT DE PARCOURIR LA LISTE*/
    Cellule *temp = s.lSerp.last->precedent;
    /*RECUPERATION DE LA POSITION DE LA TETE DU SERPENT*/
    posx = s.lSerp.last->p.posX;/*p structure position*/
    posy = s.lSerp.last->p.posY;
    /*RECUPERATION DE LA POISITION DES MURS DROIT ET BAS*/
    posxFin = DIMX - 1;
    posyFin = DIMY - 1;
	
	/* DEBUT DE LA BOUCLE*/
    /* ON PARCOURE LA LISTE POUR SAVOIR SI LA TETE SE TROUVE A LA MEME POSITION QU'UNE PARTIE DE SON CORPS*/
 	while (temp !=NULL)
	{
        if ((posx == temp->p.posX) && (posy == temp->p.posY))
        {
            return 1;
        }
        else
        {
           temp = temp->precedent;
        }
    }
	
    /*SI LA TETE DU SERPENT TOUCHE UN MUR, LA PARTIE EST FINIE*/
    if ((posx == posxFin) || (posy == posyFin) || (posx == 0) || (posy == 0))
    {
        return 1;
    }
    else 
    {
		return 0;
	}

    
}



void jouer(SDL_Surface *ecran,int difficulte)
{
	/*INITIALISATION DE SDL_TTF*/
	TTF_Init();
	
	/*CHARGEMENT DE LA POLICE*/
	TTF_Font *police;
	police = NULL;
	police = TTF_OpenFont("times.ttf", 65);
	
	/*COULEURS*/
	SDL_Color couleurNoire = {0, 0, 0};
		
	
	/*INITIALISATION DU TERRAIN*/
    int carte[DIMX][DIMY] = {{0}};

    /*DEFINITION DE M ET N , HAUTEUR ET LARGEUR DU TABLEAU*/
    int N = sizeof(carte) / sizeof(carte[0]);
    int M = sizeof(carte[0]) / sizeof(carte[0][0]);
    
    /*INITIALISATION DES VARIABLES*/
    int i,j; /* u et j permettant l'affichage du terrain avec deux boucles*/
    int res; /* Pour effectuer un scanf*/
    int touche; /* Valeur recuperée pendant le scnaf*/
    int continuer = 1; /* Permet de créer une boucle*/
    int compteur = 1; /* sert a compter le nombre de fruit mangé*/
    int compteurBonus = 0; /*sert a compter le nombre de bonus mangé*/
    int valeurScore = 0; /*variable permettant de stocker le score de la partie*/
    char chaineScore[20];
    int fin = 0; /*variable recuperant la valeur de la fonction pour terminer le jeu*/
   
    /*INITIALISATION DES HORLOGES*/
    float horloge;
    float horloge_prec;
    float intervalle_horloge = 0.05f * difficulte;
    int rafraichissement;
    
    /*INITIALISATION DES VALEURS DE DEPLACEMENTS*/
    int deplacement;

    /*INITIALISATION DES STRUCTURES DE DONNEES*/
    Liste lSerp; /* initialisation de la liste chainée pour le serpent*/
    Fruit f; /* initialisation de la structure fruit*/
    serpent sowlow; /* Initialisation du serpent*/
    
    SDL_Event event;
	
	/*INITIALISATION DES SURFACES DU JEU*/
	SDL_Surface *terrain = NULL;
	SDL_Surface *mur = NULL;
	SDL_Surface *serp = NULL;
	SDL_Surface *pomme = NULL;
	SDL_Surface *fraise = NULL;
	SDL_Surface *texte = NULL;
	SDL_Surface *texteScore = NULL;
	SDL_Surface *teteDroite = NULL;
	SDL_Surface *teteGauche = NULL;
	SDL_Surface *teteHaut = NULL;
	SDL_Surface *teteBas = NULL;
	
	/*INITIALISATION DES POSITIONS DES SURFACES*/
    SDL_Rect positionTerrain;
    SDL_Rect positionMur;
    SDL_Rect positionSerp;
    SDL_Rect positionPomme;
    SDL_Rect positionFraise;
    SDL_Rect positionTexte;
    SDL_Rect positionTexteScore;
    SDL_Rect positionTete;
    
	/*POSITIONNEMENT DES IMAGES*/
    positionTerrain.x = 0;
    positionTerrain.y = 0;
    
    positionMur.x = 0;
    positionMur.y = 0;
    
    positionSerp.x = 0;
    positionSerp.y = 0;
    
    positionPomme.x = 0;
    positionPomme.y = 0;
    
    positionFraise.x = 0;
    positionFraise.y = 0;
   
	positionTexte.x =  DIM_BLOC + 1;
	positionTexte.y =  DIM_BLOC + 1;
	
	positionTexteScore.x = DIM_BLOC * 6;
	positionTexteScore.y = DIM_BLOC + 1;
	
	positionTete.y = 0;
	positionTete.x = 0;

	/*INITIALISATION DE LA VIDEO*/
    SDL_Init(SDL_INIT_VIDEO);

    /*RECUPERATION DES IMAGES*/
    terrain = SDL_LoadBMP("images/terrain.bmp");
    mur = SDL_LoadBMP("images/mur.bmp"); 
    serp = SDL_LoadBMP("images/serpent.bmp");
    pomme = SDL_LoadBMP("images/pomme.bmp");
    fraise = SDL_LoadBMP("images/fraise.bmp");
    teteDroite = SDL_LoadBMP("images/serpentDroite.bmp");
    teteGauche = SDL_LoadBMP("images/serpentGauche.bmp");
    teteBas = SDL_LoadBMP("images/serpentBas.bmp");
    teteHaut = SDL_LoadBMP("images/serpentHaut.bmp");
    
    /*RECUPERATION DE L'IMAGE DU TEXTE*/
    texte = TTF_RenderText_Blended(police, "Score : ", couleurNoire);
   
    /*INITIALISATION DU SERPENT*/
    initSerpent(&sowlow);
    
    /*ON DEFINIE LA PREMIERE POSITION DU SERPENT*/
    positionInitialeSerpent(&sowlow,&(carte[0][0]),M);
    
    /*ON GERERE LE PREMIER FRUIT*/
    genererFruit(&f, sowlow, &carte[0][0], M);
    
    /*ON DEFINIE UNE VALEUR POUR LES MURS*/
    definitionMur(&carte[0][0], M);
     
    /*MISE EN MEMOIRE DU TEMPS*/ 
    horloge_prec = (float)clock()/(float)CLOCKS_PER_SEC;
    
    
   
    /*------------DEBUT DES INSTRUCTIONS-----------*/
    
    /*ON DEMARRE UNE BOUCLE SDL, TANT QUE CONTINUER = 1, ON ARRETE
      PAS LA BOUCLE*/
    while (continuer)
    {
		rafraichissement = 0;
		horloge = (float)clock()/(float)CLOCKS_PER_SEC; /*RECUPERATION DU TEMPS*/
		
		if (horloge-horloge_prec >= intervalle_horloge)
        {
				switch (deplacement)
				{
					/* SI DEPLACEMENT = 1, ON SE DEPLACE A GAUCHE,
					 * SI DEPLACEMENT = 2, ON SE DEPLACE A DROITE,
					 * SI DEPLACEMENT = 3, ON SE DEPLACE EN BAS,
					 * SI DEPLACEMENT = 4, ON DE DEPLACE EN HAUT */
					 
					case 1:
					deplacerGauche(&sowlow, &carte[0][0], M, &compteur, &deplacement);
					break;
					
					case 2:
					deplacerDroite(&sowlow, &carte[0][0], M, &compteur, &deplacement);
					break;
					
					case 3:
					deplacerBas(&sowlow, &carte[0][0], M, &compteur, &deplacement);
					break;
					
					case 4:
					deplacerHaut(&sowlow, &carte[0][0], M, &compteur, &deplacement);
					break;
					
					
				}
				/*CHANGEMENT DE LA VALEUR DE RAFRAICHISSEMENT, PERMET DE LANCER LA CONDITION SUIVANTE*/
                rafraichissement = 1; 
                
                /*MISE EN MEMOIRE DE LA DERNIERE HORLOGE RECUEPEREE*/
                horloge_prec = horloge;
        }
		
		if (rafraichissement==1)
        {
			/* SI LE RAFRAICHISSEMENT EST EGALE A 1, ON LANCE UNE BOUCLE D'AFFICHAGE DU TERRAIN*/
			for(i=0; i<DIMX; i++)
			{
				for(j=0; j<DIMY; j++)
				{
					/*SI L'ELEMENT DE LA CARTE QUI A POUR COORDONNE I,J VAUT 5, C'EST UN MUR*/
					if (carte[i][j] == 5)
					{
						/*ON PLACE L'IMAGE AUX BON COORDONNES, (COORDONNES PIXELS) */
						positionMur.y = i*DIM_BLOC;
						positionMur.x = j*DIM_BLOC;
						
						/*ON COLLE LA SURFACE DU MUR AUX COORDONNES CHOISIE*/
						SDL_BlitSurface(mur, NULL, ecran, &positionMur);
			
					}
					/*SI L'ELEMENT DE LA CARTE QUI A POUR COORDONNE I,J VAUT 6, C'EST UNE TETE*/
					else if (carte[i][j] == 6)
					{
						positionTete.x = j*DIM_BLOC;
						positionTete.y = i*DIM_BLOC;
							
							/*SELON L'ORIENTATION ON BLIT UNE IMAGE DIFFERENTE, HAUT BAS GAUCHE OU DROITE*/
							if (deplacement == 1)
							{
								SDL_BlitSurface(teteGauche, NULL, ecran, &positionTete);
							}
							else if (deplacement == 2)
							{
								SDL_BlitSurface(teteDroite, NULL, ecran, &positionTete);
							}
							else if (deplacement == 3)
							{
								SDL_BlitSurface(teteBas, NULL, ecran, &positionTete);
							}
							else 
							{
								SDL_BlitSurface(teteHaut, NULL, ecran, &positionTete);
							}
					}
					
					/*SI L'ELEMENT DE LA CARTE QUI A POUR COORDONNE I,J VAUT 1, C'EST UN CORPS*/
					else if (carte[i][j] == 1)
					{
			
						positionSerp.y = i*DIM_BLOC;
						positionSerp.x = j*DIM_BLOC;
						
						SDL_BlitSurface(serp, NULL, ecran, &positionSerp);
					}
			
					/*SI L'ELEMENT DE LA CARTE QUI A POUR COORDONNE I,J VAUT 4, C'EST UNE POMME*/
					else if (carte[i][j] == 4)
					{
						positionPomme.y = i*DIM_BLOC;
						positionPomme.x = j*DIM_BLOC;
			
						SDL_BlitSurface(pomme, NULL, ecran, &positionPomme);
					}
			
					/*SI L'ELEMENT DE LA CARTE QUI A POUR COORDONNE I,J VAUT 3, C'EST UNE FRAISE*/
					else if (carte[i][j] == 3)
					{
						positionFraise.y = i*DIM_BLOC;
						positionFraise.x = j*DIM_BLOC;
			
						SDL_BlitSurface(fraise, NULL, ecran, &positionFraise);
					}
				}
			}
			
		/*MISE A JOUR DE L'ECRAN*/	
		SDL_Flip(ecran);
			
		}/*FIN DU IF*/
		
		/*SI RAFRAICHISSEMENT N'EST PAS EGAL A 1, ON NE FAIT RIEN*/
		else 
		{
			;
		}
		
		
		/*DEBUT D'UNE BOUCLE DANS LAQUELLE ON ATTEND UN EVENEMENT SANS BLOQUER LE PROGRAMME*/
		while ( SDL_PollEvent( &event ) )
		{
			switch(event.type)
			{
				case SDL_QUIT:
					continuer = 0;
					SDL_Quit();
                
                case SDL_KEYDOWN: /*PRESSION D'UNE TOUCHE DU CLAVIER*/
                
					switch(event.key.keysym.sym)
					{
						case SDLK_ESCAPE: /* TOUCHE ESPACE*/
                        continuer = 0;
                        break;

						case SDLK_UP: /*  TOUCHE HAUT*/
                        deplacement = 4;
                        break;

						case SDLK_DOWN: /* TOUCHE BAS */
                        deplacement = 3;
                        break;

						case SDLK_RIGHT: /* TOUCHE DROITE */
                        deplacement = 2;
                        break;
                        
						case SDLK_LEFT: /*TOUCHE GAUCHE */
                        deplacement = 1;
                        break;
                        
                        
						default: break;
                   
					}
				}
			}
			/*FIN DE LA BOUCLE*/
		
		
    
		/* TEST SI LE FRUIT EST MANGE OU NON, SI OUI, GENERATION D'UN NOUVEAU FRUIT*/
		mangeFruit(&f, sowlow, &carte[0][0], M, &compteur);
		
		/*EFFACEMENT DE L'ECRAN*/
		SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
		
		/*RECUPERATION DU SCORE ET CONVERTION EN CHAINE DE CARACTERE PUIS EN IMAGE*/
		valeurScore = score(compteur, compteurBonus, difficulte);
		sprintf (chaineScore, "%d", valeurScore);
		texteScore = TTF_RenderText_Blended(police, chaineScore , couleurNoire);
		
		/*AFFICHAGE DU SCORE A L'ECRAN*/
		SDL_BlitSurface(texteScore, NULL, ecran, &positionTexteScore);
		SDL_BlitSurface(texte, NULL, ecran, &positionTexte);
	
		
		/* ON TEST SI LE JEU EST FINI, SI OUI, LE JEU S'ARRETE*/
		fin = testFinJeu(sowlow,&carte[0][0], M, ecran, valeurScore);
		if (fin == 0)
		{
			continuer = 1;
		}
		else 
		{
			continuer = 0;
		}	
	}/*FIN DE LA BOUCLE SDL*/
   
	
		
		/*LIBERATION DES SURFACES*/
		SDL_FreeSurface(texteScore);
		SDL_FreeSurface(mur);
		SDL_FreeSurface(serp);
		SDL_FreeSurface(fraise);
		SDL_FreeSurface(pomme);
		SDL_FreeSurface(texte);
		
		/*LIBERATION DES POLICES*/
		TTF_CloseFont(police);
		/*FIN DE SDL_TTF*/
		TTF_Quit();
		
		/*ON APPELLE LE MENU DE LA FIN DU JEU*/
		gameOver(ecran, valeurScore);
		
		SDL_FreeSurface(terrain); 
		SDL_Quit();
}

